﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//class Time {
//public:
//	Time(int hour)
//	:_hour(hour)
//	{
//		cout << "Time()" << endl;
//	}
//private:
//	int _hour;
//};
//
//class Date {
//public:
//	Date(int& x, int year, int month)
//	:_year(year)
//	,_month(month)
//	,_ref(x)// 1.根据给的参数初始化
//	,_i(0)// 2.直接给一个初始值
//	,_t(11)
//	{
//		// “Date::_ref” : 必须初始化引⽤
//		// “Date::_i” : 必须初始化常量限定类型的对象
//		// “Time”: 没有默认构造函数
//	}
//private:
//	int _year;
//	int _month;
//	int _day = 0;// 3.给缺省值
//	int& _ref;
//	const int _i;
//	Time _t;
//};


////类型转换
//class A {
//public:
//	A(int a)
//		:_a(a)
//	{}
//	A(int a, int b)
//		:_a(a)
//		,_b(b)
//	{}
//	void Print() {
//		cout << _a << ", " << _b << endl;
//	}
//	int Get() const
//	{
//		return _a + _b;
//	}
//private:
//	int _a = -1;
//	int _b = -1;
//};
//
//class B {
//public:
//	B(const A& a)
//		:_a(a.Get())
//	{}
//private:
//	int _a;
//};
//
//int main() {
//	//通过构造函数，将int型隐式转化为类类型
//	//实质是根据1构造⼀个A的临时对象，再用这个临时对象拷贝构造aa1
//	//不过编译器进行了优化，遇到连续构造加拷贝构造时优化为直接构造
//
//	A aa1 = 1;//直接构造
//	aa1.Print();
//	const A& aa2  = 1;//拷贝构造
//	//也可以多参数，C++11后支持
//	A aa3 = { 1, 2 };
//	aa3.Print();
//
//	//对象隐式转换
//	B bb1 = aa3;
//}


//静态成员
//class A {
//public:
//	A(){
//		_count++;
//	}
//	~A() {
//		_count--;
//	}
//	static int GetCount() {
//		return _count;
//	}
//
//private:
//	static int _count;//不能给缺省值
//};
//
////静态成员变量在全局进行定义
//int A::_count = 0;
//
//int main() {
//	cout << A::GetCount() << endl;
//	A a1, a2, a3;
//	cout << A::GetCount() << endl;
//}


//友元

//class B;
//class A {
//public:
//	//声明友元
//	friend void func(const A& aa, const B& bb);
//private:
//	int _a = 1;
//	int _b = 2;
//};
//
//class B {
//public:
//	//再次声明友元
//	friend void func(const A& aa, const B& bb);
//private:
//	int _a = 3;
//	int _b = 4;
//};
//
//void func(const A& aa, const B& bb) {
//	cout << "A:" << aa._a << endl;
//	cout << "B:" << bb._a << endl;
//}
//
//int main() {
//	A aa1;
//	B bb1;
//	func(aa1, bb1);
//}

//class A {
//	friend class B;
//private:
//	int _a = 10;
//	int _b = 20;
//};
//
//class B {
//public:
//	void func(const A& aa) {
//		cout << "A:" << aa._a << ", " << aa._b << endl;
//	}
//};
//
//int main() {
//	A a;
//	B b;
//	b.func(a);
//}



//内部类
//class A {
//private:
//	int _a = 1;
//	int _b = 2;
//public:
//	class B {
//	public:
//		void printA(const A& aa) {
//			cout << aa._a << "," << aa._b << endl;
//		}
//	};
//};
//
//int main() {
//	A a;
//	A::B b;
//	b.printA(a);
//}


//匿名对象
class A {
public:
	A(int a = 0) 
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A() {
		cout << "~A()" << endl;
	}
	int GetCount(){
		return _count;
	}
private:
	static int _count;
	int _a;
};
int A::_count = 100;

int main() {
	//创建有名对象
	A aa1;//无参创建时不能加括号，因为加了括号分不清是定义函数还是创建对象
	cout << endl;

	//创建匿名对象的两种方式
	A();//生命周期只有一行，可以看到，下一行就会调用析构函数
	A(2);

	//这种情况匿名对象就很好用
	cout << A().GetCount() << endl << endl;
}